home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / machserver / 1.098 / timer / sun4c.md / timerSun4c.c < prev    next >
C/C++ Source or Header  |  1990-11-09  |  10KB  |  403 lines
  1. /* 
  2.  * timerSun4c.c --
  3.  *
  4.  *    This file contains the routines that control the time of day clock 
  5.  *    and interrupt timers on the sun4c (SparcStation 1) machine. The
  6.  *    sun4c contains a Mostek MK48T12-15 chip for time of day and 
  7.  *    two interrupt timers.  
  8.  *
  9.  *    Until we get the data sheets for the Mostek chip, we use the interrupt
  10.  *    counters for both interupts and TOD.
  11.  *
  12.  * Copyright 1989 Regents of the University of California
  13.  * Permission to use, copy, modify, and distribute this
  14.  * software and its documentation for any purpose and without
  15.  * fee is hereby granted, provided that the above copyright
  16.  * notice appear in all copies.  The University of California
  17.  * makes no representations about the suitability of this
  18.  * software for any purpose.  It is provided "as is" without
  19.  * express or implied warranty.
  20.  */
  21.  
  22. #ifndef lint
  23. static char rcsid[] = "$Header: /sprite/src/kernel/timer/sun4c.md/RCS/timerSun4c.c,v 1.9 90/11/08 21:02:41 rab Exp $ SPRITE (Berkeley)";
  24. #endif /* not lint */
  25.  
  26. #include "sprite.h"
  27. #include "sys.h"
  28. #include "timer.h"
  29. #include "timerInt.h"
  30. #include "timerTick.h"
  31. #include "spriteTime.h"
  32. #include "mach.h"
  33. #include "prof.h"
  34. #include "devAddrs.h"
  35.  
  36. #include "timerMK48T12Int.h"
  37.  
  38. /*
  39.  * The sun4c contains two counters that count up to value in the limit 
  40.  * register and interrupt. The counters are defined by the following 
  41.  * structure. (Campus-1 Programmer's Model Version 7.5 page 11).
  42.  * We assign counter0 to be the call back interrupt timer and 
  43.  * counter1 to be the profile interrupt timer. Each counter and limit
  44.  * register is of the form:
  45.  *    struct {
  46.  *       int    limitReached :1; -- 1 if counter reached limit. 
  47.  *       int  value         :21; -- Value updated every microsecond. 
  48.  *       int  zeros         :10; -- Read as zero. 
  49.  *     }
  50.  */
  51.  
  52. typedef struct {
  53.     unsigned int callBackCounter; /* Call back counter */
  54.     unsigned int callBackLimit;   /* Limit register for call back counter. */
  55.     unsigned int profileCounter;  /* Profile counter. */
  56.     unsigned int profileLimit;    /* Limit register for profile counter. */
  57. } Counters;
  58.  
  59. /*
  60.  * COUNTER_SHIFT    - Number of bits to shift microsecond value for
  61.  *              counter. 
  62.  * COUNTER_LIMIT_REACH  - Bit signifying count has reached limit.
  63.  */
  64. #define    COUNTER_SHIFT 10
  65. #define    COUNTER_LIMIT_REACH 0x80000000
  66.  
  67. static volatile Counters *counterPtr = (volatile Counters *) DEV_COUNTER_ADDR;
  68.  
  69. /*
  70.  * The "free running counter"
  71.  */
  72. static Timer_Ticks todCounter;
  73.  
  74. int Timer_TimerServiceInterrupt();
  75.  
  76. /*
  77.  * Timer interval as a Time value. This is the period between callbacks.
  78.  */
  79.  
  80. static Time time = { 0, TIMER_CALLBACK_INTERVAL_APPROX};
  81.  
  82.  
  83. /* 
  84.  *----------------------------------------------------------------------
  85.  *
  86.  * Timer_TimerInit --
  87.  *
  88.  *    Initialize the periodic timer. Since there is no way to turn off
  89.  *    the counters will wait and do all the work in Timer_TimerStart().
  90.  *
  91.  *
  92.  * Results:
  93.  *    None.
  94.  *
  95.  * Side effects:
  96.  *    The timer is initialized.
  97.  *
  98.  *----------------------------------------------------------------------
  99.  */
  100. /*ARGSUSED*/
  101. void
  102. Timer_TimerInit(timer)
  103.     unsigned short     timer;
  104. { 
  105.      if (timer == TIMER_CALLBACK_TIMER) {
  106.      Mach_SetHandler(10, Timer_TimerServiceInterrupt, (ClientData) timer); 
  107.      } else if (timer == TIMER_PROFILE_TIMER) {
  108.      Mach_SetHandler(14, Timer_TimerServiceInterrupt, (ClientData) timer); 
  109.      } else {
  110.     panic("Timer_TimerInit: unknown timer %d\n", timer);
  111.      }
  112. }
  113.  
  114.  
  115. /*
  116.  *----------------------------------------------------------------------
  117.  *
  118.  * Timer_TimerStart --
  119.  *
  120.  *    Loads the specified timer with a new value to count from
  121.  *    and starts the timer.
  122.  *
  123.  *    N.B. The timer must have been initialized with Timer_TimerInit
  124.  *    before this routine is called.
  125.  *
  126.  * Results:
  127.  *    None.
  128.  *
  129.  * Side effects:
  130.  *    The timer starts ticking.
  131.  *
  132.  *----------------------------------------------------------------------
  133.  */
  134.  
  135. void
  136. Timer_TimerStart(timer)
  137.     register unsigned short timer;
  138. {
  139.     unsigned int junk;
  140.  
  141.     /*
  142.      * To start the timer we load the limit register with the correct 
  143.      * count and clear any pending interrupt. 
  144.      */
  145.      if (timer == TIMER_CALLBACK_TIMER) {
  146.      counterPtr->callBackLimit =
  147.              ((TIMER_CALLBACK_INTERVAL_APPROX) << COUNTER_SHIFT);
  148.      junk = counterPtr->callBackLimit;
  149.       DISABLE_INTR();
  150.      *Mach_InterruptReg |= MACH_ENABLE_COUNTER0_INTR_LEVEL;
  151.      ENABLE_INTR();
  152.  
  153.      } else if (timer == TIMER_PROFILE_TIMER) {
  154.      counterPtr->profileLimit =
  155.              ((TIMER_PROFILE_INTERVAL_APPROX) << COUNTER_SHIFT);
  156.      junk = counterPtr->profileLimit;
  157.          DISABLE_INTR();
  158.      *Mach_InterruptReg |= MACH_ENABLE_COUNTER1_INTR_LEVEL;
  159.      ENABLE_INTR();
  160.      } else {
  161.     panic("Timer_TimerInit: unknown timer %d\n", timer);
  162.      }
  163. #ifdef lint
  164.     junk = junk;
  165. #endif
  166.  
  167.  
  168. }
  169.  
  170.  
  171.  
  172. /*
  173.  *----------------------------------------------------------------------
  174.  *
  175.  * Timer_TimerInactivate --
  176.  *
  177.  *    Stops the timer so that it will not cause interrupts.
  178.  *
  179.  * Results:
  180.  *    None.
  181.  *
  182.  * Side effects:
  183.  *    The timer is stopped.
  184.  *
  185.  *----------------------------------------------------------------------
  186.  */
  187.  
  188. void
  189. Timer_TimerInactivate(timer)
  190.     register unsigned short timer;
  191. {
  192.     if (timer == TIMER_CALLBACK_TIMER) {
  193.     /*
  194.      * As long as we use the callback timer to keep track of time
  195.      * we shouldn't turn it off.
  196.      */
  197. #ifdef notdef
  198.      DISABLE_INTR();
  199.      *Mach_InterruptReg &= ~MACH_ENABLE_COUNTER0_INTR_LEVEL;
  200.      ENABLE_INTR();
  201. #endif
  202.     } else if (timer == TIMER_PROFILE_TIMER) {
  203.      DISABLE_INTR();
  204.      *Mach_InterruptReg &= ~MACH_ENABLE_COUNTER1_INTR_LEVEL;
  205.      ENABLE_INTR();
  206.     } else {
  207.     panic("Timer_TimerInactivate: unknown timer %d\n", timer);
  208.     }
  209.  
  210. }
  211.  
  212. /*
  213.  *----------------------------------------------------------------------
  214.  *
  215.  *  Timer_TimerServiceInterrupt --
  216.  *
  217.  *      This routine is called at every timer interrupt. 
  218.  *      It calls the timer callback queue handling if the callback timer 
  219.  *    expired and calls the profiling interrupt handling if the 
  220.  *    profile callback timer expired.
  221.  *
  222.  *  Results:
  223.  *    None.
  224.  *
  225.  *  Side Effects:
  226.  *    Routines on the timer queue may cause side effects. Profile
  227.  *    collect may take place. 
  228.  *    
  229.  *
  230.  *----------------------------------------------------------------------
  231.  */
  232.  
  233. int
  234. Timer_TimerServiceInterrupt(clientData, pc)
  235.     ClientData    clientData;            /* Really Counter number */
  236.     unsigned int    pc;        /* Only for sun4 version. */
  237. { 
  238.     register unsigned int junk;
  239.  
  240.     if ((unsigned int) clientData == TIMER_PROFILE_TIMER) {
  241.     /*
  242.      * Clear interrupt by reading limit register. 
  243.      */
  244.     junk = counterPtr->profileLimit;
  245.     TIMER_PROFILE_ROUTINE(pc);
  246. #       ifdef GATHER_STAT
  247.         timer_Statistics.profile++;
  248. #       endif
  249.     } else  if ((unsigned int) clientData == TIMER_CALLBACK_TIMER) {
  250.     /*
  251.      * Clear interrupt by reading limit register. 
  252.      */
  253.     junk = counterPtr->callBackLimit;
  254. #ifndef TOD_WORKING
  255.     /*
  256.      * Until we get the TOD chip working. Use the callback counter
  257.      * to keep track on time of day.
  258.      */
  259.      todCounter.microseconds += TIMER_CALLBACK_INTERVAL_APPROX;
  260.      if (todCounter.microseconds > ONE_SECOND) {
  261.          todCounter.seconds++;
  262.          todCounter.microseconds -= ONE_SECOND;
  263.      }
  264. #endif
  265.     if (mach_KernelMode == 0) {
  266.         Proc_GetCurrentProc()->Prof_PC = pc;
  267.     }
  268.         TIMER_CALLBACK_ROUTINE(TIMER_CALLBACK_INTERVAL_APPROX, time);
  269.     } else {
  270.     panic("Timer_TimerServiceInterrupt: Unknown timer %d\n", 
  271.             (int) clientData);
  272.     }
  273. #ifdef lint
  274.     junk = junk;
  275. #endif
  276.     return 0;
  277. }
  278.  
  279. /*
  280.  *----------------------------------------------------------------------
  281.  *
  282.  * Timer_CounterInit --
  283.  *
  284.  *    Initializes the chip's free-running counters. Until we get the
  285.  *    TOD chip just use a counter updated by the CALL BACK interrupt
  286.  *    handler.
  287.  *
  288.  *    
  289.  * Results:
  290.  *    None.
  291.  *
  292.  * Side effects:
  293.  *    None.
  294.  *
  295.  *----------------------------------------------------------------------
  296.  */
  297.  
  298. void
  299. Timer_CounterInit()
  300. {
  301.     todCounter.seconds = 0;
  302.     todCounter.microseconds = 0;
  303. }
  304.  
  305. /* 
  306.  *----------------------------------------------------------------------
  307.  *
  308.  *  Timer_GetCurrentTicks --
  309.  *
  310.  *      Return microseconds since boot.
  311.  *
  312.  *  Results:
  313.  *    The system up-time in ticks.
  314.  *
  315.  *  Side effects:
  316.  *    None.
  317.  *
  318.  *----------------------------------------------------------------------
  319.  */
  320. void
  321. Timer_GetCurrentTicks(ticksPtr)
  322.     Timer_Ticks    *ticksPtr;    /* Buffer to place current time. */
  323. {
  324.     DISABLE_INTR();
  325.  
  326.     *ticksPtr = todCounter;
  327.  
  328.     ENABLE_INTR();
  329. }
  330.  
  331. /* 
  332.  *----------------------------------------------------------------------
  333.  *
  334.  *  Timer_GetInfo --
  335.  *
  336.  *      Dummy routine to dump timer state.
  337.  *
  338.  *  Results:
  339.  *    None.
  340.  *
  341.  *  Side effects:
  342.  *    None.
  343.  *
  344.  *----------------------------------------------------------------------
  345.  */
  346. /*ARGSUSED*/
  347. void
  348. Timer_TimerGetInfo(data)
  349.     ClientData    data;    /* Not used. */
  350. {
  351. }
  352.  
  353. /*
  354.  *----------------------------------------------------------------------
  355.  *
  356.  * TimerHardwareUniversalTimeInit --
  357.  *
  358.  *     Not implemented yet.
  359.  *
  360.  * Results:
  361.  *    None.
  362.  *
  363.  * Side effects:
  364.  *    None.
  365.  *
  366.  *----------------------------------------------------------------------
  367.  */
  368.  
  369. /*ARGSUSED*/
  370. void
  371. TimerHardwareUniversalTimeInit(timePtr, localOffsetPtr, DSTPtr)
  372.     Time *timePtr;        /* Buffer to hold universal time. */
  373.     int  *localOffsetPtr;    /* Buffer to hold local offset. */
  374.     Boolean *DSTPtr;        /* Buffer to hold DST allowed flag. */
  375. {
  376. }
  377.  
  378. /*
  379.  *----------------------------------------------------------------------
  380.  *
  381.  * TimerSetHardwareUniversalTime --
  382.  *
  383.  *    Not implemented yet.
  384.  *
  385.  * Results:
  386.  *    None.
  387.  *
  388.  * Side effects:
  389.  *    None.
  390.  *
  391.  *----------------------------------------------------------------------
  392.  */
  393.  
  394. /*ARGSUSED*/
  395. void
  396. TimerSetHardwareUniversalTime(timePtr, localOffset, DST)
  397.     Time *timePtr;        /* universal time. */
  398.     int  localOffset;        /* local offset. */
  399.     Boolean DST;        /* DST allowed flag. */
  400. {
  401. }
  402.  
  403.